/*
Dominique Jannone
Guillaume Marre
Yohan Ojeda
Laurent Schiavon
*/
package model;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.Serializable;
import java.lang.management.ManagementFactory;
import java.net.ServerSocket;
import java.net.Socket;
import java.sql.ResultSet;
import java.util.Enumeration;
import java.util.Vector;
import java.util.logging.Level;
import java.util.logging.Logger;

import javax.media.rtp.RTPManager;
import javax.swing.plaf.SliderUI;

//import com.sun.xml.internal.bind.v2.runtime.reflect.opt.Const;

import Econf_Audio.AgentUpdateClient;
import Econf_Audio.RTPServeur;

public class UserServerDelegate implements Runnable {
	
	// log
		public static final Logger logger = Logger.getLogger(ConnexionDb.class.getName());
	
	//Attrihbuts
		static Socket socket;
		int compteur;
		private MainServer serveur;
		private ConnexionDb sql;
		private ResultSet resultatPreInscription, resultatIdentification, resultatPreIdentification, resultatDonneeConf;
		private String loginUser;
		private CanalAnnonceurHandler canalAnnonceur;
		private RTPServeur mgr;
		private static int PORT_DATA;
		UserServerDelegate usd = this;
		private ObjectOutputStream oos;
		private ObjectInputStream ois;
		private String[] tabInfosProfileUtilisateurCourant; // Contenu du tableau (prenom (0), nom (1), login (2) et mail (3))
		private boolean donneesPersonnellesIndisponibles; // Utiliser pour les connexions anonymes
		
		//Modification - Monitoring
		
				private double EspaceDisqueUtilise;
				private double EspaceDisqueLibre;
				private double EspaceDisqueTotal;
				private String DDNom;
				
		// Fin modification - Monitoring
		
		// Observateur
		  public MainServer getServeur() {
				return serveur;
			}
		  public ObjectOutputStream getOos() {
				return oos;
			}
		public ObjectInputStream getOis() {
				return ois;
			}
		
		
	// Constructeur primitif
	public UserServerDelegate(Socket s, int comp, MainServer mainServeur, ConnexionDb connexion, CanalAnnonceurHandler canalAnnonceur){
		serveur = mainServeur;
		this.canalAnnonceur = canalAnnonceur;
		socket = s;
		compteur = comp;
		sql=connexion;
	}



public void run() {
	  boolean fin = false;
    	try {
        	// WAIT réception d'un Objet
      	InputStream is = socket.getInputStream();
      	OutputStream os = socket.getOutputStream();
      	
        while(!fin){
          	ois = new ObjectInputStream(is);
          	oos = new ObjectOutputStream(os);
          	
          	logger.log(Level.INFO,"WAIT USD réception d'un Objet");
          	//lecture du 1er Objet "ID"
          	Object objetID = ois.readObject();
          	//int IDreceive = Integer.parseInt((String)objet );
          	logger.log(Level.INFO,"Object receive: "+objetID);
          	int IDreceive = (Integer)objetID;
          	logger.log(Level.INFO,"Object receive: "+IDreceive);
           	//Différents cas suivant la valeur de la constante IDreceive
    	          switch (IDreceive) {
    	
    	          case Constantes.DEMANDE_D_INSCRIPTION :
    	        	  logger.log(Level.INFO,"In Case: DEMANDE_D_INSCRIPTION");
    	        	  Object[] tabReceiveInscription = serveur.ReceptionObjetFromClient(this, 5, ois);
    	        	  // Récupération du login de la session utilisateur courante
    	        	  loginUser = (String) tabReceiveInscription[2];
    	        	  logger.log(Level.INFO,"Demande d'inscription faite par l'utilisateur: "+loginUser);
       	        	 // requete SQL de vérification de login et de d'ajout dans la DB
    	        	  boolean resultatInscription;
      	        	  resultatPreInscription = sql.requeteVerificationExistenceLogin(loginUser);
      	        	// on test si le contenu de la requete est vide <-> login déjà existant      	        	  
      				   	if (resultatPreInscription.next()){     				   		
      				   		resultatInscription=false;
      				   	    serveur.EnvoiReponseACK("0", "Login Utilisateur non disponible", resultatInscription, oos);
      				   		}
      				   	else {
      				   		 resultatInscription= sql.InscriptionNouvelUtilisateur(tabReceiveInscription);
      				   		 	if (resultatInscription){
      				   		 	serveur.EnvoiReponseACK("0", "Inscription réussie", resultatInscription, oos);
      				   		 	}
      				   		 	else {
      				   		 	serveur.EnvoiReponseACK("0", "Erreur lors de l'insertion dans la base", resultatInscription, oos);	
      				   		 	}
      				   	     }

    		    	break;
    		    	
    		    	
    	          case Constantes.DEMANDE_DE_CONNEXION :
    	        	  logger.log(Level.INFO,"In Case: DEMANDE_DE_CONNEXION");
    	        	  Object[] tabReceiveConnexion = serveur.ReceptionObjetFromClient(this, 3, ois);
    	        	  boolean utilisateurAnonyme;
    	        	  boolean resultat;
    	        	  loginUser= (String)tabReceiveConnexion[0];
    	        	  logger.log(Level.INFO,"Demande de connexion de l'utilisateur "+loginUser);
    	        	  utilisateurAnonyme= Boolean.valueOf(tabReceiveConnexion[2].toString());
    	        	  // On test si l'utilisateur est anonyme, si oui réponse directe au serveur -> Affichage vue anonyme
    	        	  if (utilisateurAnonyme){
    	        		  resultat=true;
    	        		  donneesPersonnellesIndisponibles=true;
    	        		  serveur.EnvoiReponseACK("0",Constantes.USAGER_ANONYME_S, resultat, oos);
    	        	  }
    	        	  else {
    	        		  // L'utilisateur n'est pas anonyme, on a donc ses données en base
    	        		  donneesPersonnellesIndisponibles=false;
    	        		  // On vérifie que le login existe dans la base avant tout traitement
			    	        	  resultatPreInscription = sql.requeteVerificationExistenceLogin(loginUser);
			    	        	  if (resultatPreInscription.next()){	    	        		  
					    	        		  if (sql.resultatApprobation(loginUser)){
					    	        	// Requete SQL demande de connexion <-> renvoie groupe et mot de l'utilisateur
					    	        	  resultatIdentification= sql.requeteIdentification(loginUser);
					    	        	  String [] tabResultatIdentification = new String [2];
					    	        	  tabResultatIdentification = sql.rendreResultatIdentification(resultatIdentification);
								    	        	  if (tabResultatIdentification[0].equals((String)tabReceiveConnexion[1])){
								    	        		  //Requête SQL pour récuperer le nom, prenom, mail pour la session de l'utiliteur
								    	        		  tabInfosProfileUtilisateurCourant= sql.renvoiNomPrenomMailUtilisateurFonctionLogin(loginUser);
								    	        		  // infos du tableau à réutiliser lorsque le client fera une demande, évite requête SQL pour rien (caching)
								    	        		  resultat = true;
								    	        		  serveur.EnvoiReponseACK("0", tabResultatIdentification[1], resultat, oos);
								  			    			}
								  			    	 else {
								  			    		resultat = false;
								  			    		serveur.EnvoiReponseACK("0", "Erreur de mot de passe", resultat, oos);
								  			    	  }
					    	        		  	}
					    	        	  else {
					    	        		  resultat = false;
						  			    		serveur.EnvoiReponseACK("0", "Inscription utilisateur non approuvée", resultat, oos);
					    	        	  		}
					    	     }
			    	        	  else {
			    	        		  resultat = false;
				  			    		serveur.EnvoiReponseACK("0", "Ce nom d'utilisateur n'est pas connu", resultat, oos);
			    	        	  }
			    	        	  
    	        	  		}
			    	     break;
			    	     
			    	     
    	          case Constantes.DEMANDE_INFOS_PERSONELLES_UTILISATEUR :
    	        	  logger.log(Level.INFO,"In Case: DEMANDE_INFOS_PERSONELLES_UTILISATEUR");
    	        	  // get info socket
    	        	  String description = (String) ois.readObject();
    	        	  logger.log(Level.INFO,description);
    		    	   if (donneesPersonnellesIndisponibles) {
    		    		   String []tabInfosAnonyme = new String [2];
    		    		   tabInfosAnonyme[0]="anonyme";
    		    		   tabInfosAnonyme[1]=loginUser;
    		    		// On envoie le nombre de ligne (ici 1)
 	    	        	  if(serveur.EnvoiReponseACK("0", ""+2 ,true, oos)){
 	    	        		  serveur.EnvoiObjectFromServerToClient(this, tabInfosAnonyme, oos);
 	    	        	  }
						
					} else {
						  // On envoie le nombre de ligne (ici 4 -> prenom,nom,login,mail)
	    	        	  if(serveur.EnvoiReponseACK("0", ""+tabInfosProfileUtilisateurCourant.length ,true, oos)){
	    	        		  serveur.EnvoiObjectFromServerToClient(this, tabInfosProfileUtilisateurCourant, oos);
	    	        	  }
						
					}
    		    	
    		    	   logger.log(Level.INFO,"Fin du case DEMANDE_INFOS_PERSONELLES_UTILISATEUR");
    	          break; 
			    	     
			    	     
         	
    	          case Constantes.DEMANDE_CREATION_CONFERENCE :
    	        	  logger.log(Level.INFO,"In Case: DEMANDE_CREATION_CONFERENCE");
    	        	  Object[] tabReceiveNewConference = serveur.ReceptionObjetFromClient(this, 20, ois);
        	        	 // requete SQL de vérification de login et de d'ajout dans la DB
     	        	 //boolean resultatNewConference= false;//sql.InscriptionNouvelUtilisateur(tabReceiveNewConference);	  	
     	        	// send resultat de la requete 0 ou 1
     	        	 if (sql.creationConference(tabReceiveNewConference)){
     	        		serveur.EnvoiReponseACK("0","Opération de création réussie", true, oos);
     	        	 }
     	        	 else {
     	        		serveur.EnvoiReponseACK("0","Echec opération de création", false, oos);
     	        	 } 
     	        	 
//     	        	  boolean resultat = true;  // TEMPORAIRE
     		    	  //constante >> REQUETE_OPERATION_IMPOSSIBLE ou REQUETE_OPERATION_REUSSI
     	        	 // serveur.EnvoiReponseACK(this, "Opération impossible", resultatNewConference, oos);
    		       	break;
    		
    		      case Constantes.DEMANDE_LISTE_CONFERENCE_PRIVEE :
    		    	  logger.log(Level.INFO,"In Case: DEMANDE_LISTE_CONFERENCE");
    		    	  // Get info de la socket 
    		    	   description = (String) ois.readObject();
    		    	   logger.log(Level.INFO,description);
    		    	  // Requete SQL liste des conférences
    		    	 int idUtilisateurCourant = sql.renvoiIdUtilisteur(loginUser);
    		    	//Vector temporaire pour stocker les informations
	 		    	 	Vector vecteurPrive = new Vector();
       		    	 // Traitement pour les conférences privées propre à l'utilisateur
				    		    	 
				    		    	 int [] tabIdConf = sql.renvoiIdConferencePriveeUtilisateur(idUtilisateurCourant);
				    		    	 
				    		    	 // Verification du contenu du tableau et exécution de z requetes
				    		    	 	for (int z = 0; z < tabIdConf.length; z++) {
											resultatDonneeConf = sql.donneesConferencesUtilisateur(tabIdConf[z], idUtilisateurCourant);
											if (resultatDonneeConf.next()){
											vecteurPrive.add(resultatDonneeConf.getString("titre"));
											vecteurPrive.add(resultatDonneeConf.getString("sujet"));
											vecteurPrive.add(resultatDonneeConf.getString("nom_conferencier"));
											// Traitement pour l'affichage de la durée côté client
												// On traite d'abord l'entrée date_heure_début de la base;
													String debutConf = resultatDonneeConf.getString("date_heure_debut");
													String [] tmpTabDebut = debutConf.split(" ");
													String date = tmpTabDebut[0];
													String horaireDebutNonFormatee = tmpTabDebut[1];
														// Formatage des données hh:mm:ss.0 -> hh:mm
														String [] tmpTabDebut2 = horaireDebutNonFormatee.split(":");
														String horaireDebutFormatee = tmpTabDebut2[0]+":"+tmpTabDebut2[1];
												// Puis on taite l'entrée date_heure_fin
													String finConf = resultatDonneeConf.getString("date_heure_fin");
													String [] tmpTabFin = finConf.split(" ");
													// La date reste la même, on l'a déjà récupéré plus haut.
													String horaireFinNonFormatee = tmpTabFin[1];
														// Formatage des données hh:mm:ss.0 -> hh:mm
														String [] tmpTabFin2 = horaireFinNonFormatee.split(":");
														String horaireFinFormatee = tmpTabFin2[0] +":"+ tmpTabFin2[1];
												// On crée une variable locale; durée que l'on ajoute dans le vecteur
													String duree = horaireDebutFormatee + " - " + horaireFinFormatee;
											vecteurPrive.add(date);
											vecteurPrive.add(duree);
											vecteurPrive.add(resultatDonneeConf.getString("role"));
											vecteurPrive.add(resultatDonneeConf.getString("statut"));
											vecteurPrive.add(resultatDonneeConf.getInt("id_conference"));
											}
										}
											
				    		    	 	
				    	// Traitement pour l'affichage des conférences publiques où l'utilisateur est conférencier
				    		    	 	
				    		    	 	String prenomNom = sql.renvoiPrenomNomUtilisateurFonctionLoginUtilisateur(loginUser);
				    		    	 	int [] tabIdConfConferencier = sql.renvoiIdConferencePubliqueUtilisateurConferencier(idUtilisateurCourant, prenomNom);
				    		    	 	
				    		    	 	// Verification du contenu du tableau et exécution de z requetes
				    		    	 	for (int x =0; x< tabIdConfConferencier.length;x++){
											resultatDonneeConf = sql.donneesConferencesUtilisateur(tabIdConfConferencier[x], idUtilisateurCourant);
											if (resultatDonneeConf.next()){
											vecteurPrive.add(resultatDonneeConf.getString("titre"));
											vecteurPrive.add(resultatDonneeConf.getString("sujet"));
											vecteurPrive.add(resultatDonneeConf.getString("nom_conferencier"));
											// Traitement pour l'affichage de la durée côté client
											// On traite d'abord l'entrée date_heure_début de la base;
												String debutConf = resultatDonneeConf.getString("date_heure_debut");
												String [] tmpTabDebut = debutConf.split(" ");
												String date = tmpTabDebut[0];
												String horaireDebutNonFormatee = tmpTabDebut[1];
													// Formatage des données hh:mm:ss.0 -> hh:mm
													String [] tmpTabDebut2 = horaireDebutNonFormatee.split(":");
													String horaireDebutFormatee = tmpTabDebut2[0]+":"+tmpTabDebut2[1];
											// Puis on taite l'entrée date_heure_fin
												String finConf = resultatDonneeConf.getString("date_heure_fin");
												String [] tmpTabFin = finConf.split(" ");
												// La date reste la même, on l'a déjà récupéré plus haut.
												String horaireFinNonFormatee = tmpTabFin[1];
													// Formatage des données hh:mm:ss.0 -> hh:mm
													String [] tmpTabFin2 = horaireFinNonFormatee.split(":");
													String horaireFinFormatee = tmpTabFin2[0] +":"+ tmpTabFin2[1];
											// On crée une variable locale; durée que l'on ajoute dans le vecteur
												String duree = horaireDebutFormatee + " - " + horaireFinFormatee;
											vecteurPrive.add(date);
											vecteurPrive.add(duree);
											vecteurPrive.add(resultatDonneeConf.getString("role"));
											vecteurPrive.add(resultatDonneeConf.getString("statut"));
											vecteurPrive.add(resultatDonneeConf.getInt("id_conference"));
											}
										}
    	 	
				    	// Traitement pour les conférences publiques où l'utilisateur est administrateur de conférence
				    		    	 	
				    		    	 	int [] tabIdConfAdminConf = sql.renvoiIdConferencePubliqueUtilisateurAdminConference(idUtilisateurCourant, prenomNom);
				    		    	 	
				    		    	 	// Verification du contenu du tableau et exécution de z requetes
				    		    	 	for (int y =0; y< tabIdConfAdminConf.length;y++){
											resultatDonneeConf = sql.donneesConferencesUtilisateur(tabIdConfAdminConf[y], idUtilisateurCourant);
											if (resultatDonneeConf.next()){
											vecteurPrive.add(resultatDonneeConf.getString("titre"));
											vecteurPrive.add(resultatDonneeConf.getString("sujet"));
											vecteurPrive.add(resultatDonneeConf.getString("nom_conferencier"));
											// Traitement pour l'affichage de la durée côté client
											// On traite d'abord l'entrée date_heure_début de la base;
												String debutConf = resultatDonneeConf.getString("date_heure_debut");
												String [] tmpTabDebut = debutConf.split(" ");
												String date = tmpTabDebut[0];
												String horaireDebutNonFormatee = tmpTabDebut[1];
													// Formatage des données hh:mm:ss.0 -> hh:mm
													String [] tmpTabDebut2 = horaireDebutNonFormatee.split(":");
													String horaireDebutFormatee = tmpTabDebut2[0]+":"+tmpTabDebut2[1];
											// Puis on taite l'entrée date_heure_fin
												String finConf = resultatDonneeConf.getString("date_heure_fin");
												String [] tmpTabFin = finConf.split(" ");
												// La date reste la même, on l'a déjà récupéré plus haut.
												String horaireFinNonFormatee = tmpTabFin[1];
													// Formatage des données hh:mm:ss.0 -> hh:mm
													String [] tmpTabFin2 = horaireFinNonFormatee.split(":");
													String horaireFinFormatee = tmpTabFin2[0] +":"+ tmpTabFin2[1];
											// On crée une variable locale; durée que l'on ajoute dans le vecteur
												String duree = horaireDebutFormatee + " - " + horaireFinFormatee;
											vecteurPrive.add(date);
										    vecteurPrive.add(duree);
											vecteurPrive.add(resultatDonneeConf.getString("role"));
											vecteurPrive.add(resultatDonneeConf.getString("statut"));
											vecteurPrive.add(resultatDonneeConf.getInt("id_conference"));
											}
										}
				    		    	 	
				      // Envoi au client, données conférences privés
				    		    	// Envoi du nombre de ligne pour l'affichage côté client
				    		    	 	int nbLigneTotal = vecteurPrive.size()/8;
				    		    	 	if (serveur.EnvoiReponseACK("0",""+nbLigneTotal ,true, oos)){}
			    		  				else {
			    		  					logger.log(Level.INFO,"Erreur envoi taille du tableau pour l'affichage");
			    		  				}
				    		    	 	
				    		    	 // Envoi du tableau au client
				    		    	 	Object [][] donneeAffichageVueConferencePrive = new Object [vecteurPrive.size()/8] [8];
				    		    	 	
				    		    	 	for (Enumeration e = vecteurPrive.elements();e.hasMoreElements();) {
				    		    			 for (int j = 0; j < vecteurPrive.size()/8; j++) {  	 	
				    		    		 donneeAffichageVueConferencePrive [j][0] = e.nextElement();
				    		    		 donneeAffichageVueConferencePrive [j][1] = e.nextElement();
				    		    		 donneeAffichageVueConferencePrive [j][2] = e.nextElement();
				    		    		 donneeAffichageVueConferencePrive [j][3] = e.nextElement();
				    		    		 donneeAffichageVueConferencePrive [j][4] = e.nextElement();
				    		    		 donneeAffichageVueConferencePrive [j][5] = e.nextElement();
				    		    		 donneeAffichageVueConferencePrive [j][6] = e.nextElement();
				    		    		 donneeAffichageVueConferencePrive [j][7] = e.nextElement();
				    		    		 }
				    		    	 	}
				    		    	 	
				    	    	  		if(serveur.EnvoiObject2DFromServerToClient(this,donneeAffichageVueConferencePrive ,oos)){
				    	    	  			logger.log(Level.INFO,"Envoi du tab OK");
				    	    	  		}
				    	    	  		else {
				    	    	  			// Erreur lors de l'envoie du tableau
				    	    	  			logger.log(Level.INFO,"Envoi du tab NON OK");
				    	    	  		}

    		       	break;
    		       	
    		       	
    		      case Constantes.DEMANDE_LISTE_CONFERENCE_PUBLIQUE :
    		    	  logger.log(Level.INFO,"In Case: DEMANDE_LISTE_CONFERENCE");
    		    	  // Get info de la socket 
    		    	   description = (String) ois.readObject();
    		    	   logger.log(Level.INFO,description);
    		    	
    		    	//Vector temporaire pour stocker les informations
	 		    	 	Vector vecteurPublique = new Vector();
 
			    		    		// Traitement pour les conférences publiques
				    		    	 	int [] tabIdConfPublique = sql.renvoiIdConferencePublique();
				    		    	 	for (int g = 0; g < tabIdConfPublique.length; g++) {
				    		    	 		logger.log(Level.INFO,"ID conference publique:"+tabIdConfPublique[g]);
				    		    	 		ResultSet resultatDonneeConfPublique = sql.donneesConferencesPublique(tabIdConfPublique[g]);
				    		    	 		resultatDonneeConfPublique.next();
				    		    	 		vecteurPublique.add(resultatDonneeConfPublique.getString("titre"));
				    		    	 		vecteurPublique.add(resultatDonneeConfPublique.getString("sujet"));
				    		    	 		vecteurPublique.add(resultatDonneeConfPublique.getString("nom_conferencier"));
				    		    	 	// Traitement pour l'affichage de la durée côté client
											// On traite d'abord l'entrée date_heure_début de la base;
												String debutConf = resultatDonneeConfPublique.getString("date_heure_debut");
												String [] tmpTabDebut = debutConf.split(" ");
												String date = tmpTabDebut[0];
												String horaireDebutNonFormatee = tmpTabDebut[1];
													// Formatage des données hh:mm:ss.0 -> hh:mm
													String [] tmpTabDebut2 = horaireDebutNonFormatee.split(":");
													String horaireDebutFormatee = tmpTabDebut2[0]+":"+tmpTabDebut2[1];
											// Puis on taite l'entrée date_heure_fin
												String finConf = resultatDonneeConfPublique.getString("date_heure_fin");
												String [] tmpTabFin = finConf.split(" ");
												// La date reste la même, on l'a déjà récupéré plus haut.
												String horaireFinNonFormatee = tmpTabFin[1];
													// Formatage des données hh:mm:ss.0 -> hh:mm
													String [] tmpTabFin2 = horaireFinNonFormatee.split(":");
													String horaireFinFormatee = tmpTabFin2[0] +":"+ tmpTabFin2[1];
											// On crée une variable locale; durée que l'on ajoute dans le vecteur
												String duree = horaireDebutFormatee + " - " + horaireFinFormatee;
											vecteurPublique.add(date);
											vecteurPublique.add(duree);
				    		    	 		vecteurPublique.add("auditeur");
				    		    	 		vecteurPublique.add(resultatDonneeConfPublique.getString("statut"));
				    		    	 		vecteurPublique.add(resultatDonneeConfPublique.getInt("id_conference"));
				    		    	 					}
				    		    	 	 nbLigneTotal = vecteurPublique.size()/8;
				    		    	 	
				    		    	 	Object [][] donneeAffichageVueConference = new Object [vecteurPublique.size()/8] [8];
			
				    		    		 for (Enumeration e = vecteurPublique.elements();e.hasMoreElements();) {
				    		    			 for (int j = 0; j < vecteurPublique.size()/8; j++) {  	 	
				    		    		 donneeAffichageVueConference [j][0] = e.nextElement();
				    		    		 donneeAffichageVueConference [j][1] = e.nextElement();
				    		    		 donneeAffichageVueConference [j][2] = e.nextElement();
				    		    		 donneeAffichageVueConference [j][3] = e.nextElement();
				    		    		 donneeAffichageVueConference [j][4] = e.nextElement();
				    		    		 donneeAffichageVueConference [j][5] = e.nextElement();
				    		    		 donneeAffichageVueConference [j][6] = e.nextElement();
				    		    		 donneeAffichageVueConference [j][7] = e.nextElement();
				    		    		 }
									}
				    		    		 
				    		    		 if (serveur.EnvoiReponseACK("0",""+nbLigneTotal ,true, oos)){}
					    		  			
				    		  				else {
				    		  					logger.log(Level.INFO,"Erreur envoi taille du tableau pour l'affichage");
				    		  				}
				    		  				
				    		  		
				    		  			// Envoi du tableau au client
				    	    	  		if(serveur.EnvoiObject2DFromServerToClient(this,donneeAffichageVueConference,oos)){
				    	    	  			logger.log(Level.INFO,"Envoi du tab OK");
				    	    	  		}
				    	    	  		else {
				    	    	  			// Erreur lors de l'envoie du tableau
				    	    	  			logger.log(Level.INFO,"Envoi du tab NON OK");
				    	    	  		}

    		       	break;
    		       	
    		      case Constantes.DEMANDE_REJOINDRE_CONFERENCE :
    		    	  logger.log(Level.INFO,"In Case: DEMANDE_REJOINDRE_CONFERENCE");
    		    	  // Get info ID de la conf 
//    		    	  String donneeClients= new String(ois.readObject().toString());
    		    	  String[] donneeClient = ((ois.readObject().toString())).split("@");
    		    	  String idConf = donneeClient[0];
    		    	  String[] infoAdresse = donneeClient[1].split("/");
    		    	  String ipClient = infoAdresse[1];
    		    	  String loginProfile = donneeClient[2];
    		    	  String roleUser = donneeClient[3];
    		    	  logger.log(Level.INFO,">>>>>>>>>>>>>>: "+idConf+" - "+ipClient+" - "+loginProfile + " - " +roleUser );
    		    	  // Requete SQL liste des conférences
    		    	  // Récupération l'id utilisateur en fontion de son login
    		    	  idUtilisateurCourant = sql.renvoiIdUtilisteur(loginUser);
//    		    	  // Récupération du nom et prenom de l'utilsateur en fonction du login (1er élement de la réponse)
    		    	  prenomNom = sql.renvoiPrenomNomUtilisateurFonctionLoginUtilisateur(loginUser);
    		    	  if (prenomNom== null){
    		    		  logger.log(Level.INFO,">>>>>>>>>>>>>>: Utilisateur anonyme: "+loginUser);
    		    		  prenomNom = "Anonyme - "+loginUser;
    		    	  }else{
    		    		  logger.log(Level.INFO,">>>>>>>>>>>>>>: "+idUtilisateurCourant+" - "+prenomNom);
    		    	  }
    		    	  
    		    	  // Ensuite on récupère le role de l'utilisateur pour la conférence en question (SQL à faire)
    		    	  //String roleUtilisateur = "conferencier";
    		    	  // Récup l'etat des conférences
    		    	  Object[][] tabIDetRTPManager = canalAnnonceur.getTabIDetRTPServeur();
    		    	  
    		    	  // Check si le tab n'est pas null
    		    	  if (tabIDetRTPManager != null){
    		    		// Check if conference is already exist
        		    	  boolean confExist = false;
    	    		    	  	for (int i = 0; i < tabIDetRTPManager.length; i++) {
    								if(tabIDetRTPManager[i][0].equals(idConf)){
    									confExist = true;
    									mgr = (RTPServeur) tabIDetRTPManager[i][1];
    								}
    							}
    	    		    	 // Si la conférence n'existe pas    		    	  	
    	    	    		    if (!confExist){
    	    	    		    	logger.log(Level.INFO,prenomNom+" >> création d'une nouvelle conférence "+ idConf);
    	    	    		    	// Prepar les ports
    	    	    		    	  int portLocalR = 6666 + canalAnnonceur.getIncrPort();
    	    		    		  	  int portLocalE = 9999 + canalAnnonceur.getIncrPort();
    	    		    		  	  int portEmission = 22220 + canalAnnonceur.getIncrPort();
    	    		    		  	// Envoi au client les ports pour la conférence: Port Local Reception & Port Local Emission
    	    	    		    	  	serveur.EnvoiReponseACK(""+portLocalR, ""+portEmission, true, oos);
    	    	    		    	mgr = canalAnnonceur.nouvelleConferenceRTPServeur(idConf, portLocalR, portLocalE, portEmission);
    	    	    		    	mgr.addIPdansTabIDetInfoUser(ipClient, usd, prenomNom, roleUser);
    	    	    		    }
    	    	    		    // La conférence existe il faut rejoindre a la conf
    	    	    		    else{
    	    	    		    	// Get les ports
  	    	    		    	  String portLocalR = canalAnnonceur.getPortLocalRecepConf(idConf);
  	    		    		  	  String portEmission = canalAnnonceur.getPortEmissionConf(idConf);
  	    		    		 // Envoi au client les ports pour la conférence: Port Local Reception & Port Local Emission
	    	    		    	  	serveur.EnvoiReponseACK(portLocalR, portEmission, true, oos);
    	    	    		    	mgr = canalAnnonceur.getMgrAvecIdConf(idConf);
    	    	    		    	logger.log(Level.INFO,"Ajout de l'utilisateur "+prenomNom+ " dans la conf "+idConf+ " avec l'ip "+ipClient);  
    	    	    		    	mgr.addIPdansTabIDetInfoUser(ipClient, usd, prenomNom, roleUser);
    	    	    		    	
    	    	    		    }
    		    	  }else {
    		    		// Prepare les ports
	    		    	  int portLocalR = 6666 + canalAnnonceur.getIncrPort();
		    		  	  int portLocalE = 9999 + canalAnnonceur.getIncrPort();
		    		  	  int portEmission = 22220 + canalAnnonceur.getIncrPort();
		    		  	// Envoi au client les ports pour la conférence: Port Local Reception & Port Local Emission
	    		    	  	serveur.EnvoiReponseACK(""+portLocalR, ""+portEmission, true, oos);
    		    		  // le tableau est null, il n'y a pas encore de conférence
	    		    	  	logger.log(Level.INFO,prenomNom+" >> création d'une nouvelle conférence "+ idConf);
    		    		  mgr = canalAnnonceur.nouvelleConferenceRTPServeur(idConf, portLocalR, portLocalE, portEmission);
    		    		  mgr.addIPdansTabIDetInfoUser(ipClient, usd, prenomNom, roleUser);
    		    	  }
    		    	  
    		    	  // update info du tableau:
    		    	  if(roleUser.equals(Constantes.ROLE_CONFERENCIER_STRING)){
    		    		  mgr.addConferencierinUpdateIHM(prenomNom);
    		    		  // MAJ statut de la conférence à En cours
    		    		  sql.miseAJourStatutConferenceAEnCours(Integer.parseInt(idConf));
    		    	  }
    		    	  else{
    		    		  mgr.addParticipantinUpdateIHM(prenomNom, roleUser);
    		    	  }
    		    	  
    	    	  		if(mgr.sendUpdateIHM()){
    	    	  			logger.log(Level.INFO,"Envoi Update OK");
    	    	  		}
    	    	  		else {
    	    	  			// Erreur lors de l'envoie du tableau
    	    	  			logger.log(Level.INFO,"Envoi Update NON OK");
    	    	  		}
    		       break;
    		       	
    		       	
    		            		      
    		      case Constantes.DEMANDE_PLAY_STOP_DemandeParole:
    		    	  logger.log(Level.INFO,"In Case: DEMANDE_PLAY_STOP_DemandeParole");
      	        	// Get info de la socket 
    		    	  	String descOrateur = (String) ois.readObject();
    		    	  	logger.log(Level.INFO,descOrateur);
    		    	  	// Get Infos recues
    		    	  	String[] infos = descOrateur.split("@");
    		    	  	String action = infos[0];
    		    	  	String idConfe = infos[1];
    		    	  	String dn = infos[2];
    		    	 // Get manager de la conférence
    		    	  	mgr = canalAnnonceur.getMgrAvecIdConf(idConfe);
    		    	  	
    		    	  	if (action.equals("Play")){
    		    	  		logger.log(Level.INFO,"DEMANDE: Play");
    		    	  	// Modification dans la conférence
        		    	  	mgr.modParticipantMicroinUpdateIHM(dn, Constantes.MICRO_SPEAK);
    		    	  	}
    		    	  	if (action.equals("Stop")){
    		    	  		logger.log(Level.INFO,"DEMANDE: Stop");
    		    	  	 // Modification dans la conférence
        		    	  	mgr.modParticipantMicroinUpdateIHM(dn, Constantes.MICRO_OK);
    		    	  	}
						if (action.equals("DemandeParole")){
							logger.log(Level.INFO,"DEMANDE: Parole");
	    		    	  // Modification dans la conférence
	    		    	  	mgr.modParticipantMicroinUpdateIHM(dn, Constantes.MICRO_ASK);
						}
    		    	  
						 // Send update pour les Clients
    		    	  	if(mgr.sendUpdateIHM()){
    		    	  		logger.log(Level.INFO,"Envoi Update OK");
    	    	  		}
    	    	  		else {
    	    	  			// Erreur lors de l'envoie du tableau
    	    	  			logger.log(Level.INFO,"Envoi Update NON OK");
    	    	  		}
    		    	  	serveur.EnvoiReponseACK("0", "Action OK: "+action, true, oos);
    		    	  	
    		    	  	logger.log(Level.INFO,"Quit case DEMANDE_ORATEUR_DemandeParole ");
    		    	  	
    		      break;
    		      
    		      
    		      case Constantes.DEMANDE_QUITE_CONFERENCE:
    		    	  logger.log(Level.INFO,"In Case: DEMANDE_QUITE_CONFERENCE");
        	        	
        	         // Get info de la socket 
      		    	  	String descQuitConference = (String) ois.readObject();
      		    	  logger.log(Level.INFO,descQuitConference);
      		    	// Get Infos recues
    		    	  	String[] infosQuitConf = descQuitConference.split("@");
    		    	  	String idConference = infosQuitConf[0];
    		    	  	String DisplayName = infosQuitConf[1];
    		    	  	String roleUserConference = infosQuitConf[2];
    		    	 // Get manager de la conférence
    		    	  	mgr = canalAnnonceur.getMgrAvecIdConf(idConference);
    		    	  	
    		    	  	if (roleUserConference.equals(Constantes.ROLE_CONFERENCIER_STRING)){
    		    	  		// Sup l'id de la conférence dans TabIdManager
    		    	  			canalAnnonceur.delIdConfInTabIdManager(idConference);
    		    	  		// State de la conf Terminé (cast du String en int)
    		    	  			sql.miseAJourStatutConferenceATerminer(Integer.parseInt(idConference));
    		    	  			
    		    	  		if (mgr.getTabUpdateConf().length == 1){ //il ne reste que le conférencier
    		    	  		//	Suprime la conférence 
//    		    	  				mgr.close();
    		    	  		}else{ //le conférencier arretye la conférence , alors qu'il y a encore des utilisateur en ligne
    		    	  			mgr.changeTabUpdatePourInformerClientFindeConference();
    		    	  			
    		    	  		// Send update pour les Clients
               		    	  	if(mgr.sendUpdateIHM()){
               		    	  		logger.log(Level.INFO,"Envoi Update OK");
               	    	  		}
               	    	  		else {
               	    	  			// Erreur lors de l'envoie du tableau
               	    	  			logger.log(Level.INFO,"Envoi Update NON OK");
               	    	  		}
               		    	//Suprime la conférence    
//        		    	  		mgr.close();
    		    	  		}
    		    	  		
    		    	  	}else {
    		    	  		 // Supp l'utilisateur de la conférence
    		    	  		
        		    	  	mgr.delParticipantinUpdateIHM(DisplayName);;
        		    	  	
           		    	 // Send update pour les Clients
           		    	  	if(mgr.sendUpdateIHM()){
           		    	  		logger.log(Level.INFO,"Envoi Update OK");
           	    	  		}
           	    	  		else {
           	    	  			// Erreur lors de l'envoie du tableau
           	    	  			logger.log(Level.INFO,"Envoi Update NON OK");
           	    	  		}
           		    	  	
           		    	  	
    		    	  	}
    		    	  	
    		    	  	serveur.EnvoiReponseACK("0", "Action OK: Quite conférence", true, oos);
    		    	  	
//    		    	  	mgr.delIPdansTabIDetInfoUser(this, DisplayName, roleUserConference);
    		    	  	
    		    	  	logger.log(Level.INFO,"Quit case DEMANDE_QUITE_CONFERENCE ");
      		      break;
    		      
      		      
    		      case Constantes.DEMANDE_VALIDATION_PROFILE:
    		    	  logger.log(Level.INFO,"In Case: DEMANDE_VALIDATION_PROFILE");
      	        	
      	         // Get info de la socket 
    		    	  	String desc = (String) ois.readObject();
    		    	  	logger.log(Level.INFO,desc);
    		    	  // Requete SQL liste des demande de profile
    		    	  		String[][] tabListInfosDemande = sql.retourneListeUtilisateurDemandeApprobation();
    		    	  // envoi le nombre de ligne du tableau
    		    	  		serveur.EnvoiReponseACK("0", ""+tabListInfosDemande.length, true, oos);
//    		    	  // Envoi du tableau au client
    	    	  		if(serveur.EnvoiObject2DFromServerToClient(this, tabListInfosDemande,oos)){
    	    	  			logger.log(Level.INFO,"Envoi du tab OK");
    	    	  		}
    	    	  		else {
    	    	  			// Erreur lors de l'envoie du tableau
    	    	  			logger.log(Level.INFO,"Envoi du tab NON OK");
    	    	  		}
    	    	  		
    		       	break;
    		       	
    		      
    		       	case Constantes.CONFIRMATION_PROFILE:
    		       		logger.log(Level.INFO,"In Case: CONFIRMATION_PROFILE");
    		       	// Get info de la socket 
      		    	  String userLoginC = (String) ois.readObject();	
    		       		sql.MiseJourApprobation(userLoginC);
    		       		logger.log(Level.INFO,"User: "+userLoginC);
    		       		serveur.EnvoiReponseACK("0", "OK", true, oos);
    		       	// Traitement pour l'envoie de mail pour confirmer l'inscription
    		       		// Récupération du mail de l'utilisateur
    		       		String destinataire=sql.renvoiMailUtilisateurFonctionLogin(userLoginC);
    		       		Courriel mail = new Courriel();
    		       		// texte à envoyer
    		       		String contenu="Bonjour," +"\n" +
						"l'équipe Econf vous remercie d'avoir choisi notre solution de webConferencing." +"\n" +
						"Votre demande d'inscription a été validé par notre équipe, vous pouvez dès maintenant utilisez le client Econf." +"\n"+
						"\n"+
						"l'équipe Econf";
    		       		// envoie du mail
    		       		mail.sendMail(destinataire, contenu);
    		       	break;
    		       	
    		       	case Constantes.SUPPRESSION_PROFILE:
    		       		logger.log(Level.INFO,"In Case: SUPPRESSION_PROFILE");
    		       	// Get info de la socket 
    		       		String userLoginS = (String) ois.readObject();	
    		       		sql.suppressionUtilisateurNonApprouve(userLoginS);
    		       		logger.log(Level.INFO,"User: "+userLoginS);
    		       		serveur.EnvoiReponseACK("0", "OK", true, oos);
    		       	// Traitement pour l'envoie de mail pour confirmer l'inscription
    		       		// Récupération du mail de l'utilisateur
    		       		destinataire=sql.renvoiMailUtilisateurFonctionLogin(userLoginS);
    		       		mail = new Courriel();
    		       		// texte à envoyer
    		       		contenu="Bonjour," +"\n" +
						"l'équipe Econf vous remercie d'avoir choisi notre solution de webConferencing." +"\n" +
						"Cependant, nous sommes dans l'impossibilité de répondre favorablement à votre demande d'inscription." +"\n"+
						"Nous invitons à réitérer votre demande ultérieurement"+
						"\n"+
						"l'équipe Econf";
    		       		// envoie du mail
    		       		mail.sendMail(destinataire, contenu);
        		       	break;
    		       	
        		       	
        		       	
    		       	case Constantes.DEMANDE_LISTE_PARTICIPANT :
    		       		logger.log(Level.INFO,"In Case: DEMANDE_LISTE_PARTICIPANT");
      	        	  // get info socket
      	        	  description = (String) ois.readObject();
      	        	logger.log(Level.INFO,description);
      		    	Object[] listUtilisateurComboBox = sql.affichageUtilisateurComboxBox();
      		    	  // On envoie le nombre de ligne, puis on envoie le tableau
      	        	  if(serveur.EnvoiReponseACK(""+0,""+listUtilisateurComboBox.length ,true, oos)){
      	        		  serveur.EnvoiObjectFromServerToClient(this, listUtilisateurComboBox, oos);
      	        	  }
    		       	break;
    		       	
    		       	
    		       	
    		       	// Modification Monitoring
    		       	
    		       		case model.Constantes.DEMANDE_INFO_SUPERVISION :
        	        	
    		       		logger.log(Level.INFO,"In Case: DEMANDE_INFO_SUPERVISION");
       		    	  	// Get info de la socket 
       		    	  	String supervision = (String) ois.readObject();
       		    	 logger.log(Level.INFO,supervision);
        	        	
        	        	com.sun.management.OperatingSystemMXBean composantSystem = (com.sun.management.OperatingSystemMXBean)
        	        	ManagementFactory.getOperatingSystemMXBean();
        	        	
        				// R�cup�ration des informations sur la m�moire RAM du serveur
        				double MemoireRAMTotale = new Double(composantSystem.getTotalPhysicalMemorySize() / (1024*1024) );
        				double MemoireRAMLibre = new Double(composantSystem.getFreePhysicalMemorySize() / (1024*1024) );
        				double MemoireRAMUtilisee = MemoireRAMTotale - MemoireRAMLibre;
        				 
        				// R�cup�ration des informations sur la m�moire SWAP du serveur
        				 double MemoireSWAPTotale = new Double(composantSystem.getTotalSwapSpaceSize() / (1024*1024));
        				 double MemoireSWAPLibre = new Double(composantSystem.getFreeSwapSpaceSize() / (1024*1024));
        				 double MemoireSWAPUtilisee = MemoireSWAPTotale - MemoireSWAPLibre;
        				
        				// R�cup�ration des informations sur les CPUs du serveur
        				// CPU time : Temps CPU utilis� par les processeurs sur lesquels la JVM fonctionne
        				 long CPUTime = new Long(composantSystem.getProcessCpuTime() / 1000000);
        				 int NbProcesseurServeur = new Integer(composantSystem.getAvailableProcessors());
        				 double ChargeCPUServeur = new Double( composantSystem.getSystemLoadAverage() / composantSystem.getAvailableProcessors());
        				 double ChargeCPULibre = (1 - ChargeCPUServeur);

        				
        				 String JavaInfo = System.getProperty("java.runtime.name") + " version " + System.getProperty("java.runtime.version") + System.getProperty("java.vm.version") + " by " + System.getProperty("java.vm.vendor");
        					
        				 String OSInfo = System.getProperty("os.name") + " Version " + System.getProperty("os.version") + " on " + System.getProperty("os.arch") + " architechture";

        				 

        				
        				 try {
        				 int confcreeprivee = sql.monitoringConferenceCreePrivee();
        				 logger.log(Level.INFO,"test 1 : " + confcreeprivee);
        				 
        				 int confcreepublique = sql.monitoringConferenceCreePublique();
        				 logger.log(Level.INFO,"test 2 : " + confcreepublique);
        				 
        				 int confcoursprivee = sql.monitoringConferenceEnCoursPrivee();
        				 logger.log(Level.INFO,"test 3 : " + confcoursprivee);
        				 
        				 int confcourspublique = sql.monitoringConferenceEnCoursPublique();
        				 logger.log(Level.INFO,"test 4 : " + confcourspublique);
        				 
        				 int confterminerprivee = sql.monitoringConferenceTerminerPrivee();
        				 logger.log(Level.INFO,"test 5 : " + confterminerprivee);
        				 
        				 int confterminerpublique = sql.monitoringConferenceTerminerPublique();
        				 logger.log(Level.INFO,"test 6 : " + confterminerpublique);
        				 
        				 int confuserinscrit = sql.monitoringUtilisateursInscrit();
        				 logger.log(Level.INFO,"test 7 : " + confuserinscrit);
        				 
        				 int confusernoninscrit = sql.monitoringUtilisateursNonInscrit();
        				 } catch (Exception e) {
        					 logger.log(Level.SEVERE,e.getClass() + ": " +  e.getMessage(), e);
        				}			 
        			
        				
        	 
        				
        					
        					File[] roots = File.listRoots();
        					boolean DD = false;
        					
        					for (File root : roots)
        					
        					{
        						while (DD == false) {
        					
        					DDNom =  root.getAbsolutePath();
        					logger.log(Level.INFO,"Disque dur : " + root.getAbsolutePath());
        					
        					EspaceDisqueTotal = new Double(root.getTotalSpace() / (1024*1024));
        					
        					EspaceDisqueLibre = new Double(root.getFreeSpace() / (1024*1024));
        					
        					EspaceDisqueUtilise = EspaceDisqueTotal - EspaceDisqueLibre;
        					
        					logger.log(Level.INFO,"Espace Disque Totale : " + EspaceDisqueTotal + " Mo");
        									
        					logger.log(Level.INFO,"Esapce Disque Utilis�e : " + EspaceDisqueUtilise  + " Mo");
        					
        					logger.log(Level.INFO,"Espace Disque Libre : " + EspaceDisqueLibre + " Mo" + "\n");
        					
        					DD = true;
        						}
        					}
        					
			Object[][] InfosMonitoringServeur = new Object[23][2];
			logger.log(Level.INFO,"test tab 1");
			InfosMonitoringServeur[0][0] = "RAM totale";
			logger.log(Level.INFO,"test tab 2");
			InfosMonitoringServeur[1][0] = "RAM utilisée";
			logger.log(Level.INFO,"test tab 3");
			InfosMonitoringServeur[2][0] = "RAM libre"; 
			InfosMonitoringServeur[3][0] = "SWAP totale"; 
			InfosMonitoringServeur[4][0] = "SWAP utilisée"; 
			InfosMonitoringServeur[5][0] = "SWAP libre"; 
			InfosMonitoringServeur[6][0] = "Nombre de processeurs"; 
			InfosMonitoringServeur[7][0] = "Charge CPU Serveur utilisée";
			InfosMonitoringServeur[8][0] = "Charge CPU Serveur libre";
			InfosMonitoringServeur[9][0] = "Version JAVA Serveur"; 
			InfosMonitoringServeur[10][0] = "Version OS Serveur"; 
			InfosMonitoringServeur[11][0] = "Nom Disque Dur"; 
			InfosMonitoringServeur[12][0] = "Taille totale Disque dur"; 
			InfosMonitoringServeur[13][0] = "Taille utilisée Disque dur"; 
			InfosMonitoringServeur[14][0] = "Taille libre Disque dur"; 
			InfosMonitoringServeur[15][0] = "Conférences créées privées"; 
			InfosMonitoringServeur[16][0] = "Conférences en cours privées"; 
			InfosMonitoringServeur[17][0] = "Conférences terminées privées"; 
			InfosMonitoringServeur[18][0] = "Conférences créées publiques"; 
			InfosMonitoringServeur[19][0] = "Conférences en cours publiques"; 
			InfosMonitoringServeur[20][0] = "Conférences terminées publiques"; 
			InfosMonitoringServeur[21][0] = "Utlisateurs inscrits"; 
			logger.log(Level.INFO,"test tab 4");
			InfosMonitoringServeur[22][0] = "Utilisateurs non inscrits";
			logger.log(Level.INFO,"test tab 5");
			InfosMonitoringServeur[0][1] = MemoireRAMTotale;
			logger.log(Level.INFO,"test tab 6");
			InfosMonitoringServeur[1][1] = MemoireRAMLibre;
			logger.log(Level.INFO,"test tab 7");
			InfosMonitoringServeur[2][1] = MemoireRAMUtilisee; 
			InfosMonitoringServeur[3][1] = MemoireSWAPTotale; 
			InfosMonitoringServeur[4][1] = MemoireSWAPLibre; 
			InfosMonitoringServeur[5][1] = MemoireSWAPUtilisee; 
			InfosMonitoringServeur[6][1] = NbProcesseurServeur; 
			InfosMonitoringServeur[7][1] = ChargeCPUServeur; 
			InfosMonitoringServeur[8][1] = ChargeCPULibre; 
			InfosMonitoringServeur[9][1] = JavaInfo; 
			InfosMonitoringServeur[10][1] = OSInfo; 
			InfosMonitoringServeur[11][1] = DDNom; 
			InfosMonitoringServeur[12][1] = EspaceDisqueTotal; 
			InfosMonitoringServeur[13][1] = EspaceDisqueLibre; 
			InfosMonitoringServeur[14][1] = EspaceDisqueUtilise; 
			InfosMonitoringServeur[15][1] = sql.monitoringConferenceCreePrivee(); 
			InfosMonitoringServeur[16][1] = sql.monitoringConferenceCreePublique(); 
			InfosMonitoringServeur[17][1] = sql.monitoringConferenceEnCoursPrivee(); 
			InfosMonitoringServeur[18][1] = sql.monitoringConferenceEnCoursPublique(); 
			InfosMonitoringServeur[19][1] = sql.monitoringConferenceTerminerPrivee(); 
			InfosMonitoringServeur[20][1] = sql.monitoringConferenceTerminerPublique();
			InfosMonitoringServeur[21][1] = sql.monitoringUtilisateursInscrit();
			InfosMonitoringServeur[22][1] = sql.monitoringUtilisateursNonInscrit(); 
        	        	
        	        	serveur.EnvoiObject2DFromServerToClient(this, InfosMonitoringServeur, oos);
        	        	logger.log(Level.INFO,"Envoi du tab OK");
        	        break;
    		       	
    		       	
    		       	
    		       	
    	          default:
    	          	break;
            
    	        	    }
    	          }
		}catch (Exception e) {
			logger.log(Level.SEVERE,e.getClass() + ": " +  e.getMessage(), e);
		  }
      
}



}
